﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace CityGames
{
    public class Juego
    {
        private string nombre;
        private string plataforma;
        private string genero;
        private string sinopsis;
        private string caratula;
        private string precioNuevo;
        private string precioSegundaMano;
        private string tarifa;
        private DateTime fechaLanzamiento;
        private string puntuacion;
        static private CADJuego cadJuego = new CADJuego();

        public string Nombre
        {
            get { return nombre; }
            set { nombre = value; }
        }

        public string Plataforma
        {
            get { return plataforma; }
            set { plataforma = value; }
        }

        public string Genero
        {
            get { return genero; }
            set { genero = value; }
        }

        public string Sinopsis
        {
            get { return sinopsis; }
            set { sinopsis = value; }
        }

        public string Caratula
        {
            get { return caratula; }
            set { caratula = value; }
        }

        public string PrecioNuevo
        {
            get { return precioNuevo; }
            set { precioNuevo = value; }
        }

        public string PrecioSegundaMano
        {
            get { return precioSegundaMano; }
            set { precioSegundaMano = value; }
        }

        public string Tarifa
        {
            get { return tarifa; }
            set { tarifa = value; }
        }

        public DateTime FechaLanzamiento
        {
            get { return fechaLanzamiento; }
            set { fechaLanzamiento = value; }
        }

        public string Puntuacion
        {
            get { return puntuacion; }
            set { puntuacion = value; }
        }

        /************************************************** Funciones de Marcos **************************************************/

        /// <summary>
        /// Constructor por defecto de la clase Juego.
        /// Inicializa todos los string a "" y la fecha de Lanzamiento a una vacía.
        /// </summary>
        public Juego()
        {
            try
            {
                nombre = "";
                plataforma = "";
                genero = "";
                sinopsis = "";
                caratula = "";
                precioNuevo = "";
                precioSegundaMano = "";
                tarifa = "";
                fechaLanzamiento = new DateTime();
                puntuacion = "";
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// Funcion que devuelve los juegos filtrados por Nombre, Genero, Plataforma y Fecha de Lanzamiento desde la fila "desde" hasta la fila "hasta" de la Base de Datos
        /// </summary>
        /// <param name="nombreJuego">
        /// Nombre del juego por el que se desea filtrar, "" corresponde a no filtrar por nombre</param>
        /// <param name="genero">
        /// Genero del juego por el que se desea filtrar, "Todos" corresponde a no filtrar por Genero</param>
        /// <param name="plataformaJuego">
        /// Plataforma del juego por la que se desea filtrar, "Todas" corresponde a no filtrar por Plataforma</param>
        /// <param name="fechaInicio">
        /// Fecha de Lanzamiento desde la que se desea filtrar</param>
        /// <param name="fechaFin">
        /// Fecha de Lanzamiento hasta la que se desea filtrar</param>
        /// <param name="desde">
        /// Número de fila de la Base de Datos desde la que se desea filtrar</param>
        /// <param name="hasta">
        /// Número de fila de la Base de Datos hasta la que se desea filtrar</param>
        /// <returns>
        /// Devuelve un DataSet con los juegos de la Base de Datos filtrados y paginados</returns>
        public DataSet ObtenerJuegosFiltradosPorNombreGeneroPlataformaFechaLanzamiento(string nombreJuego, string genero, string plataformaJuego, DateTime fechaInicio, DateTime fechaFin, int desde, int hasta)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadJuego.ObtenerJuegosFiltrados(nombreJuego, genero, plataformaJuego, fechaInicio, fechaFin, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Funcion para insertar el juego con todos sus datos rellenados en la Base de Datos
        /// </summary>
        /// <returns>
        /// Devuelve True si se ha podido realizar la inserción con éxito, False en caso contrario</returns>
        public bool InsertarJuego()
        {
            bool resultado = true;

            try
            {
                resultado = cadJuego.InsertarJuego(nombre, plataforma, genero, sinopsis, caratula, precioNuevo, precioSegundaMano, tarifa, fechaLanzamiento);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }


        /// <summary>
        /// Función que devuelve el número total de juegos que hay en la Base de Datos atendiendo a los filtros especificados
        /// </summary>
        /// <param name="nombreJuego">
        /// Nombre del juego por el que se desea filtrar, "" corresponde a no filtrar por nombre</param>
        /// <param name="genero">
        /// Genero del juego por el que se desea filtrar, "Todos" corresponde a no filtrar por Genero</param>
        /// <param name="plataformaJuego">
        /// Plataforma del juego por la que se desea filtrar, "Todas" corresponde a no filtrar por Plataforma</param>
        /// <param name="fechaInicio">
        /// Fecha de Lanzamiento desde la que se desea filtrar</param>
        /// <param name="fechaFin">
        /// Fecha de Lanzamiento hasta la que se desea filtrar</param>
        /// <returns></returns>
        public int ObtenerNumeroDeJuegosFiltradosPorNombreGeneroPlataformaFechaLanzamiento(string nombreJuego, string genero, string plataformaJuego, DateTime fechaInicio, DateTime fechaFin)
        {
            int resultado = 0;

            try
            {
                resultado = cadJuego.ObtenerNumeroDeJuegosFiltrados(nombreJuego, genero, plataformaJuego, fechaInicio, fechaFin);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Funcion que comprueba si existe el juego pasado como parámetro en la Base de Datos
        /// </summary>
        /// <param name="nombreJuego">
        /// Nombre del juego que se desea buscar</param>
        /// <param name="plataformaJuego">
        /// Plataforma del juego que se desea buscar</param>
        /// <returns>
        /// Devuelve True si existe el juego en la Base de Datos, False en caso contrario</returns>
        public bool ExisteJuego(string nombreJuego, string plataformaJuego)
        {
            bool resultado = true;
            try
            {
                resultado = cadJuego.ExisteJuego(nombreJuego, plataformaJuego);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Funcion para actualizar en la Base de Datos los cambios que se han realizado sobre un DataSet que contiene juegos filtrados de la Base de Datos
        /// </summary>
        /// <param name="juegos">
        /// DataSet con la coleccion de juegos filtrados cuyos cambios se desean reflejar en la Base de Datos</param>
        /// <param name="nombreJuego">
        /// Nombre del juego por el que se desea filtrar, "" corresponde a no filtrar por nombre</param>
        /// <param name="genero">
        /// Genero del juego por el que se desea filtrar, "Todos" corresponde a no filtrar por Genero</param>
        /// <param name="plataformaJuego">
        /// Plataforma del juego por la que se desea filtrar, "Todas" corresponde a no filtrar por Plataforma</param>
        /// <param name="fechaInicio">
        /// Fecha de Lanzamiento desde la que se desea filtrar</param>
        /// <param name="fechaFin">
        /// Fecha de Lanzamiento hasta la que se desea filtrar</param>
        /// <param name="desde">
        /// Número de fila de la Base de Datos desde la que se desea filtrar</param>
        /// <param name="hasta">
        /// Número de fila de la Base de Datos hasta la que se desea filtrar</param>
        /// <returns></returns>
        public bool ActualizarJuegos(DataSet juegos, string nombreJuego, string genero, string plataformaJuego, DateTime fechaInicio, DateTime fechaFin, int desde, int hasta)
        {
            bool resultado = false;

            try
            {
                resultado = cadJuego.ActualizarJuegos(juegos, nombreJuego, genero, plataformaJuego, fechaInicio, fechaFin, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Funcion para obtener la fecha de lanzamiento del juego con fecha de lanzamiento más alta de la Base de Datos
        /// </summary>
        /// <returns>
        /// Devuelve un DateTime con la fecha de lanzamiento del juego con fecha de lanzamiento más alta de la Base de Datos</returns>
        public DateTime ObtenerFechaMaxima()
        {
            DateTime resultado = new DateTime();

            try
            {
                resultado = cadJuego.ObtenerFechaMaxima();
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Funcion para obtener la fecha de lanzamiento del juego con fecha de lanzamiento más baja de la Base de Datos
        /// </summary>
        /// <returns>
        /// Devuelve un DateTime con la fecha de lanzamiento del juego con fecha de lanzamiento más baja de la Base de Datos</returns>
        public DateTime ObtenerFechaMinima()
        {
            DateTime resultado = new DateTime();

            try
            {
                resultado = cadJuego.ObtenerFechaMinima();
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener una coleccion de objetos para poder autocompletar los juegos en un TextBox
        /// </summary>
        /// <returns>
        /// Devuelve una coleccion de Strings para autocompletar un TextBox con todos los juegos</returns>
        public AutoCompleteStringCollection ObtenerTodosLosJuegosParaAutocompletado()
        {
            AutoCompleteStringCollection resultado =  new AutoCompleteStringCollection();

            try
            {
                resultado = cadJuego.ObtenerTodosLosJuegosParaAutocompletado();
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Funcion para obtener el número de juegos de una promocion atendiendo a los filtros especificados por parámetro
        /// </summary>
        /// <param name="codigoPromocion">
        /// Codigo de la promocion</param>
        /// <param name="nombreJuego">
        /// Cadena de texto que debe contener el nombre de los juegos que se desean mostrar</param>
        /// <param name="plataformaJuego">
        /// Plataforma de los juegos que se desean mostrar</param>
        /// <param name="generoJuego">
        /// Genero de los juegos que se desean mostrar</param>
        /// <returns></returns>
        public int ObtenerNumeroDeJuegosDePromocionFiltrados(int codigoPromocion, string nombreJuego, string plataformaJuego, string generoJuego)
        {
            int resultado = 0;

            try
            {
                resultado = cadJuego.ObtenerNumeroDeJuegosDePromocionFiltrados(codigoPromocion, nombreJuego, plataformaJuego, generoJuego);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los juegos de una promocion filtrados por los parámetros especificados y paginados para mostrarlos en un DataGridView
        /// </summary>
        /// <param name="codigoPromocion">
        /// Codigo de la promocion de los juegos que se desean mostrar</param>
        /// <param name="nombreJuego">
        /// Cadena de texto que debe contener el título de los juegos que se van a mostrar</param>
        /// <param name="plataformaJuego">
        /// Plataforma de los juegos que se desean mostrar</param>
        /// <param name="generoJuego">
        /// Genero de los juegos que se desean mostrar</param>
        /// <param name="desde">
        /// Entero que indica desde que número de fila se desea mostrar</param>
        /// <param name="hasta">
        /// Entero que indica hasta que número de fila se desea mostrar</param>
        /// <returns></returns>
        public DataSet ObtenerJuegosDePromocionPaginados(int codigoPromocion, string nombreJuego, string plataformaJuego, string generoJuego, int desde, int hasta)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadJuego.ObtenerJuegosDePromocionPaginados(codigoPromocion, nombreJuego, plataformaJuego, generoJuego, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        public bool RellenarDatosDeJuego(string nombreJuego, string plataformaJuego)
        {
            bool resultado = false;
            DataTable datos = new DataTable();

            if(ExisteJuego(nombreJuego, plataformaJuego))
            {
                resultado = true;
                datos = cadJuego.ObtenerDatosDeJuego(nombreJuego, plataformaJuego);

                nombre = datos.Rows[0]["Nombre"].ToString();
                plataforma = datos.Rows[0]["Plataforma"].ToString();
                genero = datos.Rows[0]["Genero"].ToString();
                sinopsis = datos.Rows[0]["Sinopsis"].ToString();
                caratula = datos.Rows[0]["Caratula"].ToString();
                precioNuevo = datos.Rows[0]["PrecioNuevo"].ToString();
                precioSegundaMano = datos.Rows[0]["PrecioSegundaMano"].ToString();
                tarifa = datos.Rows[0]["Tarifa"].ToString();
                fechaLanzamiento = DateTime.Parse(datos.Rows[0]["FechaLanzamiento"].ToString());
                puntuacion = datos.Rows[0]["Puntuacion"].ToString();
            }

            return resultado;
        }

        public DataSet ObtenerImagenesDeJuego(string nombreJuego, string plataformaJuego)
        {
            DataSet resultado = new DataSet();

            try
            {

                resultado = cadJuego.ObtenerImagenesDeJuego(nombreJuego, plataformaJuego);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        public bool InsertarImagenDeJuego(string nombreJuego, string plataformaJuego, string nombreFichero)
        {
            bool resultado = false;

            try
            {
                resultado = cadJuego.InsertarImagenDeJuego(nombreJuego, plataformaJuego, nombreFichero);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        public bool BorrarImagenDeJuego(string nombreFichero)
        {
            bool resultado = false;

            try
            {
                resultado = cadJuego.BorrarImagenDeJuego(nombreFichero);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        public DataSet ObtenerTodosLosJuegosFiltrados(string nombreJuego, string generoJuego, string plataformaJuego)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadJuego.ObtenerTodosLosJuegosFiltrados(nombreJuego, generoJuego, plataformaJuego);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /************************************************** Fin Funciones de Marcos **************************************************/

        /***************************************************** Funciones de Mirellys *************************************************/
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public DataTable ObtenerNombreJuegos()
        {
            DataTable resultado = new DataTable();

            try
            {
                resultado = cadJuego.ObtenerNombreJuegos();
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="nombreJuego"></param>
        /// <param name="genero"></param>
        /// <param name="plataformaJuego"></param>
        /// <returns></returns>
        public int ObtenerNumeroDeJuegosParaPromocion(string nombreJuego, string genero, string plataformaJuego)
        {
            int resultado = 0;

            try
            {
                resultado = cadJuego.ObtenerNumeroDeJuegosParaPromocion(nombreJuego, genero, plataformaJuego);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="nombreJuego"></param>
        /// <param name="genero"></param>
        /// <param name="plataformaJuego"></param>
        /// <param name="desde"></param>
        /// <param name="hasta"></param>
        /// <returns></returns>
        public DataSet ObtenerJuegosFiltradosParaPromocion(string nombreJuego, string genero, string plataformaJuego, int desde, int hasta)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadJuego.ObtenerJuegosFiltradosParaPromocion(nombreJuego, genero, plataformaJuego, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="nombreJuego"></param>
        /// <param name="genero"></param>
        /// <param name="plataformaJuego"></param>
        /// <returns></returns>
        public DataSet ObtenerTodosJuegosFiltradosParaPromocion(string nombreJuegoF, string generoF, string plataformaJuegoF)
        {
            DataSet resultado = new DataSet();
            
            try
            {
                resultado = cadJuego.ObtenerTodosJuegosFiltradosParaPromocion(nombreJuegoF, generoF, plataformaJuegoF);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool InsertarJuegoVirtualPromociones()
        {
            bool resultado = false;

            try
            {
                resultado = cadJuego.InsertarJuegoVirtualPromociones(nombre, plataforma, genero, sinopsis, caratula, precioNuevo, precioSegundaMano, tarifa, fechaLanzamiento);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public int ObtenerNumeroDeJuegosVirtuales()
        {
            int resultado = 0;

            try
            {
                resultado = cadJuego.ObtenerNumeroDeJuegosVirtuales();
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="desde"></param>
        /// <param name="hasta"></param>
        /// <returns></returns>
        public DataSet ObtenerJuegosVirtuales(int desde, int hasta)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadJuego.ObtenerJuegosVirtuales(desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool BorrarJuegosVirtuales()
        {
            bool resultado = false;

            try
            {
                resultado = cadJuego.BorrarJuegosVirtuales();
            }
            catch(Exception ex)
            {
                throw ex;
            }
            return resultado;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool BorrarUnJuegoVirtual()
        {
            bool resultado = false;

            try
            {
                resultado = cadJuego.BorrarUnJuegoVirtual(nombre, plataforma);
            }
            catch(Exception ex)
            {
                throw ex;
            }
            return resultado;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="nombre"></param>
        /// <returns></returns>
        public int ObtenerNumeroDeJuegosEditarPromocion(int codigo)
        {
            int resultado = 0;

            try
            {
                resultado = cadJuego.ObtenerNumeroDeJuegosEditarPromocion(codigo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="nombre"></param>
        /// <param name="desde"></param>
        /// <param name="hasta"></param>
        /// <returns></returns>
        public DataSet ObtenerJuegosEditarPromocion(int codigo, int desde, int hasta)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadJuego.ObtenerJuegosEditarPromocion(codigo, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }


        public bool InsertarJuegosVirtualesDePromocionExistente(int codigoPromocion)
        {
            bool resultado = false;

            try
            {
                resultado = cadJuego.InsertarJuegosVirtualesDePromocionExistente(codigoPromocion);
            }
            catch(Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        public DataSet ObtenerXTopGames()
        {
            DataSet resultado;

            try
            {
                resultado = cadJuego.ObtenerXTopGames();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return resultado;
        }

        public DataSet ObtenerXUltimosLanzamientos()
        {
            DataSet resultado;

            try
            {
                resultado = cadJuego.ObtenerXUltimosLanzamientos();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return resultado;
        }

        public DataSet ObtenerXProximosLanzamientos()
        {
            DataSet resultado;

            try
            {
                resultado = cadJuego.ObtenerXProximosLanzamientos();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return resultado;
        }
        /************************************************** Fin Funciones de Mirellys ************************************************/
        /**************************************************Funciones de Ruben ************************************************/

        /// <summary>
        /// Funcion que devuelve la ruta de la caratula de un juego
        /// </summary>        
        /// <param name="nombreJuego">
        /// El nombre del juego</param>
        /// <param name="plataformaJuego">
        /// La plataforma del juego</param>
        /// <returns>
        /// La ruta a la foto de la caratula.
        /// </returns>
        public string GetCaratula(string nombreJuego, string plataformaJuego)
        {
            string caratula = "";
            try
            {
                caratula = cadJuego.GetCaratula(nombreJuego, plataformaJuego);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return caratula;
        }

        /// <summary>
        /// Funcion que devuelve el precio de un juego
        /// </summary>        
        /// <param name="nombreJuego">
        /// El nombre del juego</param>
        /// <param name="plataformaJuego">
        /// La plataforma del juego</param>
        /// <param name="tipo">
        /// El tipo del juego (nuevo o segunda mano)</param>
        /// <returns>
        /// El precio del juego
        /// </returns>
        public string GetPrecio(string nombreJuego, string plataformaJuego, string tipo)
        {
            string precio = "";
            try
            {
                precio = cadJuego.GetPrecio(nombreJuego, plataformaJuego, tipo);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return precio;
        }
        /************************************************** Fin Funciones de Ruben ************************************************/
        /**************************************************Funciones de Enrique ************************************************/
        public DataSet ObtenerTopGames(string plataforma)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadJuego.ObtenerTopGames(plataforma);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return resultado;
        }

        public DataSet ObtenerTopGamesGenero(string plataforma, string genero)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadJuego.ObtenerTopGamesGenero(plataforma, genero);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return resultado;
        }

        public DataSet ObtenerAllGames(string plataforma)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadJuego.ObtenerAllGames(plataforma);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        public DataSet ObtenerAllGamesPorLetra(string plataforma, string letra)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadJuego.ObtenerAllGamesPorLetra(plataforma, letra);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        public DataSet ObtenerUltimosLanzamientos(string plataforma)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadJuego.ObtenerUltimosLanzamientos(plataforma);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        public DataSet ObtenerProximosLanzamientos(string plataforma)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadJuego.ObtenerProximosLanzamientos(plataforma);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /**************************************************Fin Funciones de Enrique ************************************************/
    }
}
